package jzlb

import (
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
)

type Lb_列表 struct {
	原始数据 []any
	读写许可 *sync.RWMutex
	初始化  bool
}

func (列表 *Lb_列表) Kqxcaq_开启线程安全() {
	if 列表.读写许可 == nil {
		var 锁 sync.RWMutex
		列表.读写许可 = &锁
	}
}
func New_列表(是否_线程安全 ...bool) (返回_列表 Lb_列表) {
	返回_列表.Qk_清空()
	if len(是否_线程安全) > 0 && 是否_线程安全[0] {
		返回_列表.Kqxcaq_开启线程安全()
	}
	return
}

func Cjlb_创建列表(添加值 ...any) (返回_列表 Lb_列表, 返回_错误 error) {
	返回_错误 = 返回_列表.Cj_创建(添加值...)
	return
}
func Cjlb_创建列表_线程安全(添加值 ...any) (返回_列表 Lb_列表, 返回_错误 error) {
	返回_列表.Kqxcaq_开启线程安全()
	返回_错误 = 返回_列表.Cj_创建(添加值...)
	return
}
func (列表 *Lb_列表) 初始化切片() {
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	if !列表.初始化 {
		列表.原始数据 = make([]any, 0)
		列表.初始化 = true
	}
}

func (列表 *Lb_列表) Cj_创建(添加值 ...any) (返回_错误 error) {
	列表.初始化切片()
	for i, v := range 添加值 {
		if 新值, ok := v.(Jzb_键值表); ok {
			赋值 := 新值.Dmap_到map()
			添加值[i] = 赋值
			返回_错误 = 切片和map值类型筛选(赋值)

			if 返回_错误 != nil {
				return
			}
		} else if 新值, ok := v.(Lb_列表); ok {
			赋值 := 新值.Dqp_到切片()
			添加值[i] = 赋值
			返回_错误 = 切片和map值类型筛选(赋值)
			if 返回_错误 != nil {
				return
			}
		} else {
			返回_错误 = 切片和map值类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}

	}
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	新值, _ := q_切片和map深拷贝(添加值)
	ok := false
	列表.原始数据, ok = 新值.([]any)
	if !ok {
		返回_错误 = errors.New("赋值失败")
		return
	}
	return
}

// 支持 []any 和 []map[string]any ==> []map[string]any 自动转换成 []any
func (列表 *Lb_列表) Cqpzr_重切片载入(切片 any) (返回_错误 error) {
	列表.初始化切片()
	返回_错误 = 切片和map值类型筛选(切片)
	if 返回_错误 != nil {
		return
	}
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	switch 当前值 := 切片.(type) {
	case []any:
		新值, _ := q_切片和map深拷贝(当前值)
		ok := false
		列表.原始数据, ok = 新值.([]any)
		if !ok {
			返回_错误 = errors.New("赋值失败")
			return
		}
		return
	case []map[string]any:
		新值, _ := q_切片和map深拷贝(当前值)
		ok := false
		列表.原始数据, ok = 新值.([]any)
		if !ok {
			返回_错误 = errors.New("赋值失败")
			return
		}
		return
	default:
		返回_错误 = fmt.Errorf("错误: 类型 %T 不是支持的基本类型", 当前值)
		return
	}

}
func (列表 *Lb_列表) Cjsonzr_重JSON载入(JSON文本 string) (返回_错误 error) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	返回_错误 = json.Unmarshal([]byte(JSON文本), &列表.原始数据)
	return
}

// 将当前数据内的 time.time  时间类型  和 []byte 字节集 自动转换成 文本格式
func (列表 *Lb_列表) Gsxz_格式修整() (返回_结果 bool) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	转换表 := 切片和map深拷贝json前byte组处理(列表.原始数据)
	列表.原始数据, 返回_结果 = 转换表.([]any)
	return
}
func (列表 *Lb_列表) Cwbfg_重文本分割(原始文本, 分割字符 string) (返回_分割数量 int) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	返回切片 := strings.Split(原始文本, 分割字符)
	列表.原始数据 = make([]any, len(返回切片))
	for i, v := range 返回切片 {
		列表.原始数据[i] = v
	}
	返回_分割数量 = len(返回切片)
	return
}
func (列表 *Lb_列表) Cwbfg_重文本分割_空白符(原始文本 string) (返回_分割数量 int) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	返回切片 := strings.Fields(原始文本)
	列表.原始数据 = make([]any, len(返回切片))
	for i, v := range 返回切片 {
		列表.原始数据[i] = v
	}
	返回_分割数量 = len(返回切片)
	return
}

func (列表 *Lb_列表) Hbdwb_合并到文本(合并连接符 string) (返回_值 string) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	切片 := make([]string, len(列表.原始数据))
	for i, v := range 列表.原始数据 {
		切片[i] = fmt.Sprintf("%v", v)
	}
	返回_值 = strings.Join(切片, 合并连接符)
	return
}

// 会把字节集 自动转换成文本
func (列表 *Lb_列表) Djson_到JSON() (返回_值 string) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	转换列表 := 切片和map深拷贝json前byte组处理(列表.原始数据)
	JSON, err := json.Marshal(转换列表)
	if err != nil {
		返回_值 = "[]"
		return
	}
	返回_值 = string(JSON)
	return
}

func (列表 *Lb_列表) Clb_重列表_安全载入(来源列表 Lb_列表) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	列表.原始数据 = 来源列表.Dqp_到切片()

}

func (列表 *Lb_列表) Aqkld_安全克隆到_新列表() (返回_值 Lb_列表) {
	返回_值.Qk_清空()
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	返回_值.Cqpzr_重切片载入(列表.原始数据)
	return
}

func (列表 *Lb_列表) Qk_清空() bool {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	列表.原始数据 = make([]any, 0)
	return true
}

func (列表 *Lb_列表) Dqp_到切片() (返回_值 []any) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	新切片, _ := q_切片和map深拷贝(列表.原始数据)
	返回_值, _ = 新切片.([]any)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qz_取值(路径或索引 string, 索引 ...string) (返回_值 any, 返回_错误 error) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	返回_值, 返回_错误 = q_切片和map取值(列表.原始数据, 路径组)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qwb_取文本(路径或索引 string, 索引 ...string) (返回_值 string) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	返回_值 = any_到文本(值)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qzs_取整数(路径或索引 string, 索引 ...string) (返回_值 int) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	文本值 := any_到文本(值)
	位置 := strings.Index(文本值, ".")
	if 位置 != -1 {
		文本值 = 文本值[:位置]
	}
	结果, err := strconv.ParseInt(文本值, 0, 64)
	if err != nil {
		//返回_错误 = err
		return
	}
	返回_值 = int(结果)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qsjdxs_取双精度小数(路径或索引 string, 索引 ...string) (返回_值 float64) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	文本值 := any_到文本(值)
	返回_值, _ = strconv.ParseFloat(文本值, 64)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qljz_取逻辑值(路径或索引 string, 索引 ...string) (返回_值 bool) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	文本值 := any_到文本(值)
	返回_值, _ = strconv.ParseBool(文本值)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qmap_取map(路径或索引 string, 索引 ...string) (返回_值 map[string]any) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case map[string]any:
		返回_值 = 当前值
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是map[string]any")
		return
	}
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qjzb_取键值表(路径或索引 string, 索引 ...string) (返回_值 Jzb_键值表) {
	返回_值.Qk_清空()
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case map[string]any:
		返回_值.Cmapzr_重map载入(当前值)
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是map[string]any")
		return
	}
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qqp_取切片(路径或索引 string, 索引 ...string) (返回_值 []any) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []any:
		返回_值 = 当前值
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是[]any")
		return
	}
}

func (列表 *Lb_列表) Qlb_取列表(路径或索引 string, 索引 ...string) (返回_值 Lb_列表) {
	返回_值.Qk_清空()
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []any:
		返回_值.Cqpzr_重切片载入(当前值)
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是[]any")
		return
	}
}

// 路径  用 . 分割 但 不分割 \' \' 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Qzjj_取字节集(路径或索引 string, 索引 ...string) (返回_值 []byte) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []byte:
		返回_值 = 当前值
		return
	default:
		文本值 := any_到文本(当前值)
		返回_值 = []byte(文本值)
		return
	}
}

func (列表 *Lb_列表) Qsjrq_取时间日期(路径或索引 string, 索引 ...string) (返回_值 time.Time) {
	值, 返回_错误 := 列表.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case time.Time:
		返回_值 = 当前值
		return
	default:
		文本值 := any_到文本(当前值)
		返回_值, _ = time.Parse("2006-01-02 15:04:05", 文本值)
		return
	}
}

func (列表 *Lb_列表) Qsl_取数量() int {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	return len(列表.原始数据)
}

// 路径  用 . 分割 但 不分割  \' \' 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zz_置值(添加值 any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	if 新值, ok := 添加值.(Jzb_键值表); ok {
		添加值 = 新值.Dmap_到map()
	} else if 新值, ok := 添加值.(Lb_列表); ok {
		添加值 = 新值.Dqp_到切片()
	}
	返回_错误 = 切片和map值类型筛选(添加值)
	if 返回_错误 != nil {
		return
	}
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	返回_错误 = q_切片和map置值(列表.原始数据, 路径组, 添加值)
	return
}

func (列表 *Lb_列表) Zqptj_子切片添加(添加值 any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	if 新值, ok := 添加值.(Jzb_键值表); ok {
		添加值 = 新值.Dmap_到map()
	} else if 新值, ok := 添加值.(Lb_列表); ok {
		添加值 = 新值.Dqp_到切片()
	}
	返回_错误 = 切片和map值类型筛选(添加值)
	if 返回_错误 != nil {
		return
	}
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	返回_错误 = q_切片和map子切片添加值(列表.原始数据, 路径组, 添加值)
	return
}

// 单个 或 按顺序 连续添加
func (列表 *Lb_列表) Tjz_添加值(添加值 ...any) (返回_错误 error) {
	for i, v := range 添加值 {
		if 新值, ok := v.(Jzb_键值表); ok {
			赋值 := 新值.Dmap_到map()
			添加值[i] = 赋值
			返回_错误 = 切片和map值类型筛选(赋值)

			if 返回_错误 != nil {
				return
			}
		} else if 新值, ok := v.(Lb_列表); ok {
			赋值 := 新值.Dqp_到切片()
			添加值[i] = 赋值
			返回_错误 = 切片和map值类型筛选(赋值)
			if 返回_错误 != nil {
				return
			}
		} else {
			返回_错误 = 切片和map值类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}

	}

	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	新值, _ := q_切片和map深拷贝(添加值)
	新切片, ok := 新值.([]any)
	if !ok {
		返回_错误 = errors.New("错误,添加失败")
		return
	}
	列表.原始数据 = append(列表.原始数据, 新切片...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zwb_置文本(添加值, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	返回_错误 = 列表.Zz_置值(添加值, 路径)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zzs_置整数(添加值 int, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zsjdxs_置双精度小数(添加值 float64, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zlg_置逻辑(添加值 bool, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zzjj_置字节集(添加值 []byte, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zsjrq_置时间日期(添加值 time.Time, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zmap_置map(添加值 map[string]any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zjzb_置键值表(添加值 Jzb_键值表, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zqp_置切片(添加值 []any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (列表 *Lb_列表) Zlb_置列表(添加值 Lb_列表, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
// 自动会把 []map[string]any 转换成 []any
func (列表 *Lb_列表) Zqpmapz_置切片map组(添加值 []map[string]any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 列表.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 正常支持 列表里套键值表查询  如[]map[]   []any 类型查询  默认 键值="索引值" 如  索引值="无敌" and 索引值 !="哈哈"
// @ 逻辑判断符号 支持  "||" or OR,    "&& and ADN"
// @ 等式判断符号 支持  "~= LIKE  like (包含 支持 单个站位符号 % 如  键 like '%哈哈')",
// "!~= NOTLIKE  notlike (包含 支持 单个站位符号 % )", "<=", ">=", "!=", "=", ">", "<"
// @ 运算符   "=", "+", "-", "*", "/", "%"(求余数)
// @ 反回新列表
func (列表 *Lb_列表) Cx_查询(条件语句 string) (返回_列表 Lb_列表, 返回_错误 error) {
	返回_列表.Qk_清空()
	返回_组 := make([]any, 0)
	分割条件 := []string{"||", "&&", "(", ")", "!~=", "~=", "<=", ">=", "!=", "=", "+", "-", "*", "/", "%", ">", "<"}
	条件切片 := t_条件分割_带原条件(条件语句, 分割条件)
	for i, v := range 条件切片 {
		if v == "and" || v == "ADN" {
			条件切片[i] = "&&"
		} else if v == "or" || v == "OR" {
			条件切片[i] = "||"
		} else if v == "NOTLIKE" || v == "notlike" {
			条件切片[i] = "!~="
		} else if v == "LIKE" || v == "like" {
			条件切片[i] = "~="
		}

	}

	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for _, v := range 列表.原始数据 {
		添加组 := make([]string, len(条件切片))
		copy(添加组, 条件切片)
		switch 当前值 := v.(type) {
		case map[string]any:

			结果, err := m_map查询_带参数(分割条件, 添加组, 当前值)
			if err != nil {
				返回_错误 = err
				return
			}
			if 结果 {
				返回_组 = append(返回_组, 当前值)
			}
		default:
			新map := map[string]any{"索引值": 当前值}
			结果, err := m_map查询_带参数(分割条件, 添加组, 新map)
			if err != nil {
				返回_错误 = err
				return
			}
			if 结果 {
				返回_组 = append(返回_组, 新map)
			}
		}
	}
	返回_列表.Cqpzr_重切片载入(返回_组)
	return
}

// []any 类型查询  默认 键值="索引值" 如  索引值="无敌" and 索引值 !="哈哈"
// @ 逻辑判断符号 支持  "||" or OR,    "&& and ADN"
// @ 等式判断符号 支持  "~= LIKE  like (包含 支持 单个站位符号 % 如  键 like '%哈哈')",
// "!~= NOTLIKE  notlike (包含 支持 单个站位符号 % )", "<=", ">=", "!=", "=", ">", "<"
// @ 运算符   "=", "+", "-", "*", "/", "%"(求余数)
// @ 位置  如果 没有对应 则返回 -1
func (列表 *Lb_列表) Cz_查找(条件语句 string, 开始位置 ...int) (返回_位置 int, 返回_错误 error) {
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	分割条件 := []string{"||", "&&", "(", ")", "!~=", "~=", "<=", ">=", "!=", "=", "+", "-", "*", "/", "%", ">", "<"}
	条件切片 := t_条件分割_带原条件(条件语句, 分割条件)
	for i, v := range 条件切片 {
		if v == "and" || v == "ADN" {
			条件切片[i] = "&&"
		} else if v == "or" || v == "OR" {
			条件切片[i] = "||"
		} else if v == "NOLIKE" || v == "notlike" {
			条件切片[i] = "~="
		} else if v == "TLIKE" || v == "like" {
			条件切片[i] = "!~="
		}

	}
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for i, v := range 列表.原始数据 {
		添加组 := make([]string, len(条件切片))
		copy(添加组, 条件切片)
		if i < 判断开始位置 {
			continue
		}
		switch 当前值 := v.(type) {
		case map[string]any:
			结果, err := m_map查询_带参数(分割条件, 添加组, 当前值)
			if err != nil {
				返回_错误 = err

				return
			}
			if 结果 {
				返回_位置 = i
				return
			}
		default:
			新map := map[string]any{"索引值": 当前值}
			结果, err := m_map查询_带参数(分割条件, 添加组, 新map)
			if err != nil {
				返回_错误 = err
				return
			}
			if 结果 {
				返回_位置 = i
				return
			}
		}
	}
	return
}
func (列表 *Lb_列表) Czks_查找快速(主键名称 string, 查找内容 any, 开始位置 ...int) (返回_位置 int) {
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for i, v := range 列表.原始数据 {
		if i < 判断开始位置 {
			continue
		}
		switch 当前值 := v.(type) {
		case map[string]any:
			if 新值, ok := 当前值[主键名称]; ok && (新值 == 查找内容 || any_到文本(新值) == any_到文本(查找内容)) {
				返回_位置 = i
				return
			}

		}

	}

	return
}

// 类型 和 数据 完全一致的查找
func (列表 *Lb_列表) Czks_查找快速_绝对匹配(主键名称 string, 查找内容 any, 开始位置 ...int) (返回_位置 int) {
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for i, v := range 列表.原始数据 {
		if i < 判断开始位置 {
			continue
		}
		switch 当前值 := v.(type) {
		case map[string]any:
			if 新值, ok := 当前值[主键名称]; ok && 新值 == 查找内容 {
				返回_位置 = i
				return
			}

		}

	}

	return
}

func (列表 *Lb_列表) Scz_删除值(路径或索引 string, 索引 ...string) (返回_错误 error) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	if len(列表.原始数据) == 0 {
		列表.原始数据 = make([]any, 0)
	}

	返回值, 返回_错误 := q_切片和map删除值(列表.原始数据, 路径组)
	if 值, ok := 返回值.([]any); ok && 返回_错误 == nil {
		列表.原始数据 = 值
		fmt.Println("值",值)
	}
	return

}

func (列表 *Lb_列表) Cwjzr_重文件载入(文件路径 string) (返回_错误 error) {
	var data []byte
	data, 返回_错误 = os.ReadFile(文件路径)
	if 返回_错误 != nil {
		return
	}
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.Lock()
		defer 列表.读写许可.Unlock()
	}
	返回_错误 = json.Unmarshal(data, &列表.原始数据)
	if 返回_错误 != nil {
		return
	}
	return
}

func (列表 *Lb_列表) Bcdwj_保存到文件(文件路径 string) (返回_错误 error) {
	列表.初始化切片()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	转换表 := 切片和map深拷贝json前byte组处理(列表.原始数据)
	JSON, err := json.Marshal(转换表)
	if err != nil {
		返回_错误 = err
		return
	}
	返回_错误 = os.WriteFile(文件路径, []byte(JSON), os.ModePerm)
	return
}

// @唯一标识的键 就是用哪个键的值做索引  要值求唯一性 否则 会被最后一个 值的值替换
// {唯一标识的键的值:{原来列表数据}}
// 只支持 []map[string]any
func (列表 *Lb_列表) Hqsyb_获取索引表_带数据(唯一标识的键 string) (返回_值 Jzb_键值表, 返回_错误 error) {
	返回_值.Qk_清空()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for _, v := range 列表.原始数据 {
		switch 当前值 := v.(type) {
		case map[string]any:
			if 值, ok := 当前值[唯一标识的键]; ok {
				返回_值.Zz_置值(当前值, "'"+any_到文本(值)+"'")
			} else {
				返回_错误 = errors.New("错误:唯一标识的键 出现不存在 ")
				return
			}
		default:
			返回_错误 = errors.New("错误:列表值类型错误  必须是 map[string]any")
			return
		}
	}
	return
}

// @唯一标识的键 就是用哪个键的值做索引  要值求唯一性 否则 会被最后一个 值的值替换
// {唯一标识的键的值:原来列表的位置}
// 只支持 []map[string]any
func (列表 *Lb_列表) Hqsyb_获取索引表_带位置(唯一标识的键 string) (返回_值 Jzb_键值表, 返回_错误 error) {
	返回_值.Qk_清空()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for i, v := range 列表.原始数据 {
		switch 当前值 := v.(type) {
		case map[string]any:
			if 值, ok := 当前值[唯一标识的键]; ok {
				返回_值.Zz_置值(i, "'"+any_到文本(值)+"'")
			} else {
				返回_错误 = errors.New("错误:唯一标识的键 出现不存在 ")
				return
			}
		default:
			返回_错误 = errors.New("错误:列表值类型错误  必须是 map[string]any")
			return
		}
	}
	return
}
